/*
 * @Author: zouzhirui 804250471@qq.com
 * @Date: 2025-02-25 11:27:23
 * @LastEditors: zouzhirui 804250471@qq.com
 * @LastEditTime: 2025-02-25 15:31:46
 * @FilePath: \002ov\run.js
 * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
 */
/*
 * @Author: zouzhirui 804250471@qq.com
 * @Date: 2025-02-24 14:28:53
 * @LastEditors: zouzhirui 804250471@qq.com
 * @LastEditTime: 2025-02-25 15:02:34
 * @FilePath: run.js
 * @Description: 流水线
 */
import simpleGit from "simple-git";
import path from "path";
import fs from "fs"
import {exec, execSync} from 'child_process'

const repoUrl = 'https://codeup.aliyun.com/66ecea0d37a6d88172290c6d/wyzx_web/overhaul-web.git';
const projectName = 'overhaul'
// 当前项目
const targetPath = path.resolve('./', projectName);
const nodeModulesPath = path.resolve('./', `${projectName}/node_modules`);
const args = process.argv.slice(2)
const projectScriptName = args[0] // 对应项目打包命令
const SCRIPT_TO_BRANCH = {
    staging: 'overhaul/test',
    production: 'overhaul/release',
}

async function cloneSpecificBranch() {

    const branchName = SCRIPT_TO_BRANCH[projectScriptName];
    console.log(`对应项目中打包命令(${projectScriptName}), 对应分支(${branchName})`)
    let git
    // 判断文件夹是否存在
    if (!fs.existsSync(targetPath)) {
        // 如果文件夹不存在，则创建它
        fs.mkdirSync(targetPath, {recursive: true}); // 使用 recursive: true 可以创建多级目录
        console.log(`Folder created: ${targetPath}`);
    } else {
        console.log(`Folder already exists: ${targetPath}`);
    }
    git = simpleGit();
    await initGitRepository(git, projectName, repoUrl)
    await checkoutRemoteBranch(git, branchName)
    await installDepByTargetDir()
    await buildStart()


}

/**
 * 初始化
 * @param git
 * @returns {Promise<void>}
 */
async function initGitRepository(git, projectName, repoUrl) {
    // 初始化一个新的 Git 仓库
    isGitRepository(git).then(async (res) => {
        if(!res){
            try {
                await git.init();
                // 添加远程仓库
                await git.addRemote(projectName, repoUrl);
                console.log('初始化一个新的 Git 仓库successfully');
            } catch (err) {
                console.error('Error 初始化一个新的 Git 仓库:', err);
            }
        }
    })
    
}


/**
 * 获取最新分支代码
 * @param git
 * @param branchName
 * @returns {Promise<void>}
 */
async function checkoutRemoteBranch(git, branchName) {
    try {
        // 拉取所有远程分支
        await git.fetch(['--all', '--prune']);

        // 检查本地是否已存在该分支
        const branches = await git.branch();
        const branchExists = branches.all.includes(branchName);
        console.log('全部分支', branches);
        
        if (branchExists) {
            // 如果本地已存在该分支，直接切换到该分支
            await git.checkout(branchName);
            console.log(`如果本地已存在该分支，直接切换到该分支: ${branchName}`);
            // 拉取最新代码
            console.log(git.status())
            // await updateCurrentBranch(git)
            // console.log(`拉取最新代码合并到当前分支: ${branchName}`);
        } else {
            // 如果本地不存在该分支，从远程检出并创建本地分支
            await git.checkout(['-b', branchName, `origin/${branchName}`]);
            console.log(`如果本地不存在该分支，从远程检出并创建本地分支: ${branchName}`);
        }
    } catch (err) {
        console.error('Error fetching and checking out branch:', err);
    }
}

/**
 * 判断依赖并决定是否安装
 * @returns {Promise<void>}
 */
async function installDepByTargetDir() {
    if (!fs.existsSync(nodeModulesPath)) {
        process.chdir(targetPath);
        console.log(`当前工作目录为: ${process.cwd()}`, '开始安装...');
        // 安装依赖,然后构建
        exec('npm install', (error, stdout, stderr) => {
            if (error) {
                console.error(`执行错误: ${error.message}`);
                return;
            }
            if (stderr) {
                console.error(`标准错误输出: ${stderr}`);
                return;
            }
            console.log(`标准输出:\n${stdout}`);
        });
    }
}

async function buildStart() {
    try {
        process.chdir(targetPath);
        console.log(`当前工作目录为: ${process.cwd()}`, '开始构建');
        exec(`npm run build:${projectScriptName}`, (error, stdout, stderr) => {
            if (error) {
                console.error(`执行错误: ${error.message}`);
                return;
            }
            if (stderr) {
                console.error(`标准错误输出: ${stderr}`);
                return;
            }
            console.log(`标准输出:\n${stdout}`);
        });
    } catch (err) {
        console.error(`无法进入目录: ${targetPath}`);
        console.error(err);
    }
}
async function isGitRepository(git) {
    try {
        // 尝试获取仓库状态
        await git.status();
        console.log('This directory is already a Git repository.');
        return true;
    } catch (err) {
        // 如果目录不是一个 Git 仓库，status 方法会抛出错误
        console.warn('This directory is not a Git repository:', err);
        return false;
    }
}
// 拉取最新代码合并到当前分支
async function updateCurrentBranch(git) {
    try {
        // 获取当前分支名称
        const currentBranch = await git.revparse(['--abbrev-ref', 'HEAD']);
        console.log(`Current branch: ${currentBranch}`);

        // 拉取最新代码并合并到当前分支
        await git.pull('origin', currentBranch);

        console.log(`Updated current branch: ${currentBranch}`);
    } catch (err) {
        console.error('Error updating current branch:', err);
    }
}

await cloneSpecificBranch();
